﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ShareCode.Util
{
    /// <summary>
    /// snowflake的结构如下(每部分用-分开):
    // 0 - 0000000000 0000000000 0000000000 0000000000 0 - 00000 - 00000 - 000000000000
    // 第一位为未使用，接下来的41位为毫秒级时间(41位的长度可以使用69年)，然后是5位datacenterId和5位workerId(10位的长度最多支持部署1024个节点）
    // ，最后12位是毫秒内的计数（12位的计数顺序号支持每个节点每毫秒产生4096个ID序号）
    // 一共加起来刚好64位，为一个Long型。(转换成字符串长度为18)
    /// </summary>
    public class SnowflakeIDcreatorBase
    {
        //基准时间,因为只能69年，所以这里尽量设置一个离现在近的时间戳
        private const long Twepoch = 1628068366245L;
        //机器标识位数
        //const int WorkerIdBits = 5;
        private const int WorkerIdBits = 6;
        //数据标志位数
        //const int DatacenterIdBits = 5;
        private const int DatacenterIdBits = 1;
        //序列号识位数
        //const int SequenceBits = 12;
        //从上面省出来了3位，这样一来就有15位了，也就是每毫秒可以产生 32,768个
        //2个数据中心，每个数据中心64台服务器，足够了，一般都用不了8台数据服务器
        private const int SequenceBits = 15;
        //机器ID最大值
        private const long MaxWorkerId = -1L ^ (-1L << WorkerIdBits);
        //数据标志ID最大值
        private const long MaxDatacenterId = -1L ^ (-1L << DatacenterIdBits);
        //序列号ID最大值
        private const long SequenceMask = -1L ^ (-1L << SequenceBits);
        //机器ID偏左移12位
        private const int WorkerIdShift = SequenceBits;
        //数据ID偏左移20位
        private const int DatacenterIdShift = SequenceBits + WorkerIdBits;
        //时间毫秒左移22位
        public const int TimestampLeftShift = SequenceBits + WorkerIdBits + DatacenterIdBits;
        private long _lastTimestamp = -1L;

        public long WorkerId { get; protected set; }
        public long DatacenterId { get; protected set; }
        public long Sequence { get; internal set; }

        public SnowflakeIDcreatorBase()
        {
            Init();
        }

        /// <summary>
        /// 子类重构此方法，取得不同工作组和数组中心配置
        /// </summary>
        public virtual void Init()
        {
            Init(0, 0, 0);
        }

        public void Init(long workerId, long datacenterId, long sequence)
        {

            // 如果超出范围就抛出异常
            if (workerId > MaxWorkerId || workerId < 0)
            {
                throw new ArgumentException($"worker Id 必须大于0，且不能大于MaxWorkerId： {MaxWorkerId}");
            }

            if (datacenterId > MaxDatacenterId || datacenterId < 0)
            {
                throw new ArgumentException($"region Id 必须大于0，且不能大于MaxWorkerId： {MaxDatacenterId}");
            }

            //先检验再赋值
            WorkerId = workerId;
            DatacenterId = datacenterId;
            Sequence = sequence;
        }


        private readonly object _lock = new object();
        protected static SnowflakeIDcreatorBase? snowflakeIDcreator { get; set; }

        public long _NextId()
        {
            lock (_lock)
            {
                long timestamp = TimeGen();
                if (timestamp < _lastTimestamp)
                {
                    throw new Exception($"时间戳必须大于上一次生成ID的时间戳.  拒绝为{_lastTimestamp - timestamp}毫秒生成id");
                }

                //如果上次生成时间和当前时间相同,在同一毫秒内
                if (_lastTimestamp == timestamp)
                {
                    //sequence自增，和sequenceMask相与一下，去掉高位
                    Sequence = (Sequence + 1) & SequenceMask;
                    //判断是否溢出,也就是每毫秒内超过1024，当为1024时，与sequenceMask相与，sequence就等于0
                    if (Sequence == 0)
                    {
                        //等待到下一毫秒
                        timestamp = TilNextMillis(_lastTimestamp);
                    }
                }
                else
                {
                    //如果和上次生成时间不同,重置sequence，就是下一毫秒开始，sequence计数重新从0开始累加,
                    //为了保证尾数随机性更大一些,最后一位可以设置一个随机数
                    Sequence = 0;//new Random().Next(10);
                }

                _lastTimestamp = timestamp;
                return ((timestamp - Twepoch) << TimestampLeftShift) | (DatacenterId << DatacenterIdShift) | (WorkerId << WorkerIdShift) | Sequence;
            }
        }

        // 防止产生的时间比之前的时间还要小（由于NTP回拨等问题）,保持增量的趋势.
        protected long TilNextMillis(long lastTimestamp)
        {
            long timestamp = TimeGen();
            while (timestamp <= lastTimestamp)
            {
                timestamp = TimeGen();
            }
            return timestamp;
        }

        // 获取当前的时间戳
        private static readonly DateTime Jan1st1970 = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
        protected long TimeGen()
        {
            return (long)(DateTime.UtcNow - Jan1st1970).TotalMilliseconds;
        }
    }

}
